---
title: Eclipse Vert.x 3.6.0 released!
category: releases
authors:
  - name: Julien Viet
    github_id: vietj
summary: We are pleased to announce the Eclipse Vert.x 3.6.0 release.
---

We are pleased to announce the Eclipse Vert.x 3.6.0 release.

As always, the community contributions have been key in achieving this milestone. 
To all of you who participated: thank you, you are awesome!

Without further ado, let's take a look at some of the most exciting new features and enhancements.  

#### Vert.x Cassandra client

In this release we introduce the [Vert.x Cassandra client](https://github.com/vert-x3/vertx-cassandra-client), an extension for interation with [Apache Cassandra](http://cassandra.apache.org/).

The client supports:
* prepared queries
* batching
* query streaming
* bulk fetching
* low level fetching

To give you an idea of how the API usage may looks like, we provide this example:

```java
cassandraClient.queryStream("SELECT my_string_col FROM my_keyspace.my_table where my_key = 'my_value'", queryStream -> {
    if (queryStream.succeeded()) {
    CassandraRowStream stream = queryStream.result();

    // resume stream when queue is ready to accept buffers again
    response.drainHandler(v -> stream.resume());

    stream.handler(row -> {
        String value = row.getString("my_string_col");
        response.write(value);

        // pause row stream when we buffer queue is full
        if (response.writeQueueFull()) {
        stream.pause();
        }
    });

    // end request when we reached end of the stream
    stream.endHandler(end -> response.end());

    } else {
    queryStream.cause().printStackTrace();
    // response with internal server error if we are not able to execute given query
    response
        .setStatusCode(500)
        .end("Unable to execute the query");
    }
});
```

#### Vert.x for Kotlin

Vert.x for Kotlin has been updated to the very recent Kotlin 1.3 (and coroutines 1.0).

Vert.x 3.5 introduced a powerful way to write synchronous non-blocking code with Kotlin coroutines:

```kotlin
val result = awaitResult<ResultSet> { client.queryWithParams("SELECT TITLE FROM MOVIE WHERE ID=?", json { array(id) }, it) };
```

In this release, `awaitResult` idiom as extension methods are provided, so now you can directly write:

```kotlin
val result = client.queryWithParamsAwait("SELECT TITLE FROM MOVIE WHERE ID=?", json { array(id) })
```

Note the `Await` suffix: all Vert.x asynchronous methods provide now an _awaitified_ extension.

#### Web API gateways

The new [Vert.x Web API Service](https://vertx.io/docs/vertx-web-api-service/java/) module allows you to
 create [Vert.x Web API Contract](https://vertx.io/docs/vertx-web-api-contract/java/) gateways.

![Web API Service Architecture](/images/blog/vertx-web-api-service/vertx-web-api-service.png)

`@WebApiServiceGen` can annotate your service interface to handle
[OpenAPI 3](https://www.openapis.org/): [Vert.x Web API Service](https://vertx.io/docs/vertx-web-api-service/java/)
requests:

```java
@WebApiServiceGen
interface TransactionService {

  void getTransactionsList(String from, String to, OperationRequest context, Handler<AsyncResult<OperationResponse>> resultHandler);

  void putTransaction(JsonObject body, OperationRequest context, Handler<AsyncResult<OperationResponse>> resultHandler);
}
```

The `OpenAPI3RouterFactory` web router becomes an API gateway sending requests directly to your services.

These services are powered by the Vert.x [event bus](https://vertx.io/docs/vertx-core/java/#event_bus) and benefits
 from features like load balancing and clustering.

Check the [complete documentation](https://vertx.io/docs/vertx-web-api-service/java/) for more details (a tutorial post is coming soon!)

#### Web Client

Our beloved [WebClient](https://vertx.io/docs/vertx-web-client/java/) is now capable of handling client sessions. The
`WebClientSession` is a client extension that is very helpful when you need to manage cookies on the client side.

```java
// The session is created per user
// from now on cookies are handled by the session
WebClientSession session = WebClientSession.create(client);
```

Cherry on the cake, the web client is now capable of performing server side response checks using _response predicates_:

```java
client
  .get(8080, "myserver.mycompany.com", "/some-uri")
  .expect(ResponsePredicate.SC_SUCCESS)
  .expect(ResponsePredicate.JSON)
  .send(result -> { ... });
```

The server side response must validate the expectations defined before sending the request in order to make the response
successful, relieving the user code to perform these checks manually. Of course many out of box expecations are provided
and you can always create your own to implement custom checks.

#### Use templating everywhere

Template engines can now be used outside the realm of Vert.x Web.
One great use case is to use them to generate email content:

```java
TemplateEngine template = ...

template.render(new JsonObject(), "my-template.txt, res -> {
   // Send result with the Vert.x Mail client
});
```

#### OpenID Connect Discovery

[Oauth2](https://vertx.io/docs/vertx-auth-oauth2/java/) has been greatly enhanced to support more of OpenID Connect, the most noticible is the support of `OpenID Connect Discovery 1.0`.

What this means for the end user is that, configuration is now a trivial task, as it is "*discoverd*" from the server, e.g.:

```java
OpenIDConnectAuth.discover(vertx,
  new OAuth2ClientOptions()
    .setSite("https://accounts.google.com")
    .setClientID("clientId"),
  res -> {
    if (res.succeeded()) {
      // the setup call succeeded.
      // at this moment your auth is ready to use and
      // google signature keys are loaded so tokens can be decoded and verified.
    } else {
      // the setup failed.
    }
});
```

If you know your **clientId** and your provider server URL (of course), all the remaining endoints, key signature algorithms and *JSON Web Keys* are "discovered" for you and
configured to the auth provider.

#### Password Hashing strategy

Vert.x auth components now support user defined password hashing strategies, If you're not happy with the provided implementations: `SHA512` or `PKDBF2` you can now provide your own strategy
so it can be used with `JDBC` or `Mongo` auth.

The hash verification algorithm has been improved to be time constant, regardless of the result, which protects Vert.x
applications from hash timing attacks.

#### Externalized configuration of Vert.x options

Whether you run your Vert.x app with the CLI or as an executable JAR with the `Launcher`, you can now provide Vert.x
options as a command line parameter:

```
java -jar my-app.jar -options /path/to/my/file.json
```

Or with the CLI:

```
vertx run my-verticle.js -options /path/to/my/file.json
```

This is particularly useful for complex clustered event-bus setups (encryption, public host vs cluster host...).

#### And more...

Here are some other important improvements you can find in this release:

- Java 11 support (unless a Vert.x module depends on a third-party dependency that does not support it yet)
- Hazelcast Cluster Manager [support for lite members](/docs/vertx-hazelcast/java/#_using_lite_members)
- [Simplified database transaction management](/blog/simplified-database-transaction-management-with-the-vert-x-rxjava-api/) with the Vert.x _Rxified_ API
- Event-bus interceptors
- Documentation improvements
  - Cluster administration with [Infinispan](/docs/vertx-infinispan/java/#_cluster_administration) and [Hazelcast](/docs/vertx-hazelcast/java/#_cluster_administration) cluster managers
  - _Rxified_ API in the Vert.x [Kafka](/docs/vertx-kafka-client/java/#_rxjava_2_api), [Web](/docs/vertx-web-client/java/#_rxjava_2_api) and [Mongo](/docs/vertx-mongo-client/java/#_rxjava_2_api) clients
- Performance improvements
- And obviously we have the usual bug fixes!

#### Finally

The [3.6.0 release notes](https://github.com/vert-x3/wiki/wiki/3.6.0-Release-Notes) can be found on the wiki, as well as the list of [deprecations and breaking changes](https://github.com/vert-x3/wiki/wiki/3.6.0-Deprecations-and-breaking-changes)

Docker images are available on [Docker Hub](https://hub.docker.com/u/vertx/).

The Vert.x distribution can be downloaded on the website but is also available from [SDKMan](http://sdkman.io/index.html) and [HomeBrew](http://brew.sh/).

The event bus client using the SockJS bridge is available from:

* [NPM](https://www.npmjs.com/package/vertx3-eventbus-client)
* [Bower](https://github.com/vert-x3/vertx-bus-bower)
* [WebJars](http://www.webjars.org/)

The release artifacts have been deployed to [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22io.vertx%22%20AND%20v%3A%223.6.0%22) and you can get the distribution on [Bintray](https://bintray.com/vertx/downloads/distribution/3.6.0/view).

That's it! Happy coding and see you soon on our user or dev [channels](https://vertx.io/community).
